package com.sdkj.dspservice.modules.demand.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sdkj.dspservice.common.base.service.impl.CrudServiceImpl;
import com.sdkj.dspservice.common.utils.DateUtils;
import com.sdkj.dspservice.common.utils.StringUtils;
import com.sdkj.dspservice.common.utils.UserUtils;
import com.sdkj.dspservice.common.utils.dsp.CdpUtils;
import com.sdkj.dspservice.modules.demand.dao.DemandDao;
import com.sdkj.dspservice.modules.demand.dao.DemandDetailsDao;
import com.sdkj.dspservice.modules.demand.entity.Demand;
import com.sdkj.dspservice.modules.demand.entity.DemandDetails;
import com.sdkj.dspservice.modules.demand.service.DemandService;
import com.sdkj.dspservice.modules.sys.entity.User;
import com.sdkj.dspservice.modules.sys.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;

/**
 * 需求service实现类
 *
 * @author tm
 */
@Service
@Transactional(readOnly = true)
public class DemandServiceImpl extends CrudServiceImpl<DemandDao, Demand> implements DemandService {

    @Autowired
    private DemandDetailsDao demandDetailsDao;
    @Autowired
    private UserService userService;

    @Override
    @Transactional(readOnly = false)
    public boolean saveOrUpdate(Demand demand) {
        boolean isNewRecord = demand.isNewRecord();
        User currentUser = UserUtils.getCurrentUser();
        if (isNewRecord) {
            // 是插入，则当前用户为创建用户，
            demand.setNowUserId(currentUser.getId());
            // 状态为草稿
            demand.setStatus(Demand.STATUS_DRAFT);
        }
        if (StringUtils.isBlank(demand.getCode())) {
            // 获取最大编号
            String maxCode = dao.getMaxCode();
            // 获取当前日期
            String nowDate = DateUtils.formatDate(new Date(), "yyyyMMdd");
            // 编号按照yyyyMMdd + 三位数
            if (StringUtils.isBlank(maxCode)) {
                demand.setCode(nowDate + "001");
            } else {
                // 获取编号日期
                String dateString = maxCode.substring(0, 8);
                // 判断是否为当前日期，为当前日期，则最后三位数+1，否则从001开始
                if (nowDate.equals(dateString)) {
                    // 获取最后三位数
                    int threeNumber = Integer.parseInt(maxCode.substring(8));
                    // 数字+1并且转为字符串，不足三位补0
                    int nowNumber = threeNumber + 1;
                    String nowNumberString = String.valueOf(nowNumber);
                    if (nowNumber < 10) {
                        nowNumberString = "00" + nowNumberString;
                    } else if (nowNumber < 100) {
                        nowNumberString = "0" + nowNumberString;
                    }
                    demand.setCode(nowDate + nowNumberString);
                } else {
                    demand.setCode(nowDate + "001");
                }
            }
        }
        return super.saveOrUpdate(demand);
    }

    /**
     * 开始并直接到待审核
     * demandDetails
     *
     * @return
     */
    @Override
    @Transactional(readOnly = false)
    public void startAndIssue(String id) {
        Demand demand = dao.selectById(id);
        // 第一次流转到已提交
        DemandDetails demandDetails = new DemandDetails();
        demandDetails.setDemandId(id);
        demandDetails.setDemand(demand);
        demandDetails.setUserId(demand.getCreateBy());
        demandDetails.setMakeType(DemandDetails.MAKE_TYPE_FLOW);
        flow(demandDetails);
        // 第二次流转到已审核，用户为项目负责人，直接获取胡道航为项目负责人
//        List<String> userIdList = userService.listIdByRoleEnName(Role.EN_NAME_DIRECTOR);
//        if (!userIdList.isEmpty()) {
            demandDetails.setId(null);
            demandDetails.setUserId(userService.getByCdpUserId("rRGoYQml").getId());
            flow(demandDetails);
//        }
    }

    @Override
    public int getCountToDo() {
        return dao.getCountToDo(UserUtils.getCurrentUserId());
    }

    /**
     * 关联分页查询
     *
     * @param page
     * @param wrapper
     * @return
     */
    @Override
    public IPage<Demand> pageLink(IPage<Demand> page, Wrapper<Demand> wrapper) {
        return dao.pageLink(page, wrapper);
    }

    /**
     * 流程流转（makeType不管什么情况必填）
     * demandDetails
     *
     * @return
     */
    @Override
    @Transactional(readOnly = false)
    public int flow(DemandDetails demandDetails) {
        Date nowDate = new Date();
        // 本次填入的实际工时
        Integer nowActualWorkingHours = demandDetails.getDemand().getActualWorkingHours();
        // 本次填入的预计完成时间
        Date estimateFinishDate = demandDetails.getDemand().getEstimateFinishDate();
        // 本次填入的预估工时
        Integer estimateWorkingHours = demandDetails.getDemand().getEstimateWorkingHours();
        // 需求ID
        String demandId = demandDetails.getDemand().getId();
        // 获取当前需求
        Demand demand = dao.selectById(demandDetails.getDemand().getId());
        // 获取本流程最后流程段
        DemandDetails lastDemandDetails = demandDetailsDao.getLastByDemandId(demandId);
        // 如果lastDemandDetails不为空，则最后流程插入结束时间，花费时间
        if (lastDemandDetails != null) {
            lastDemandDetails.setEndDate(nowDate);
            lastDemandDetails.setSpendTime((int) DateUtils.pastHour(lastDemandDetails.getCreateDate(), nowDate));
            demandDetailsDao.updateById(lastDemandDetails);
        }
        // 插入一条新的需求详情
        // 根据操作类型插入不同的状态
        String demandStatus;
        String demandFlowStatus;
        String demandUserId = demandDetails.getUserId();
        switch (demandDetails.getMakeType()) {
            // 驳回
            case DemandDetails.MAKE_TYPE_REJECT:
                // 驳回时，状态为已驳回，流程状态为已驳回
                demandStatus = Demand.STATUS_REJECT;
                demandFlowStatus = Demand.FLOW_STATUS_REJECT;
                // 除待完成外所有节点驳回都是到需求处理人，待完成驳回到需求处理人
                if(Demand.FLOW_STATUS_WAIT_FINISH.equals(lastDemandDetails.getDemandFlowStatus())){
                    // 获取本需求最后一个待处理状态的详情的用户，即为需求处理人
                    QueryWrapper<DemandDetails> queryWrapper = new QueryWrapper<>();
                    queryWrapper.eq("demand_id", demandId);
                    queryWrapper.eq("demand_flow_status", Demand.FLOW_STATUS_PROCESS);
                    queryWrapper.orderByDesc("flow_sort");
                    DemandDetails handlerDemandDetails = demandDetailsDao.selectList(queryWrapper).get(0);
                    demandUserId = handlerDemandDetails.getUserId();
                }else {
                    demandUserId = demand.getCreateBy();
                }
                break;
            // 正常流转
            case DemandDetails.MAKE_TYPE_FLOW:
                /*
                  正常流转分两种情况
                    1.当前流程为驳回状态，需要流转，流程状态为上次流程状态，用户为上次流程用户
                    2.当前流程为非驳回状态，需要流转，新流程状态为当前流程状态+1
                 */
                if (Demand.FLOW_STATUS_REJECT.equals(demand.getFlowStatus())) {
                    // 驳回
                    // 获取上次流程详情，获取方法，最后流程的flow_sort - 1
                    DemandDetails searchDemandDetails = new DemandDetails();
                    searchDemandDetails.setFlowSort(lastDemandDetails.getFlowSort() - 1);
                    searchDemandDetails.setDemandId(demandId);
                    DemandDetails dd = demandDetailsDao.selectList(new QueryWrapper<>(searchDemandDetails)).get(0);

                    demandStatus = dd.getDemandStatus();
                    demandFlowStatus = dd.getDemandFlowStatus();
                    demandUserId = dd.getUserId();
                } else {
                    // 非驳回
                    demandStatus = Demand.STATUS_DRAFT.equals(demand.getStatus()) ? Demand.STATUS_PROCESSING : demand.getStatus();
                    demandFlowStatus = String.valueOf(Integer.parseInt(StringUtils.isNotBlank(demand.getFlowStatus()) ? demand.getFlowStatus() : "0") + 1);
                }
                break;
            // 已处理提交
            case DemandDetails.MAKE_TYPE_PROCESSED:
                // 已处理提交时，状态为已处理，流程状态为待完成
                demandStatus = Demand.STATUS_PROCESSED;
                demandFlowStatus = Demand.FLOW_STATUS_WAIT_FINISH;
                // 如果填入实际工时，则根据填入的工时，未填入默认为预估工时
                if (nowActualWorkingHours != null) {
                    demand.setActualWorkingHours(nowActualWorkingHours);
                } else {
                    demand.setActualWorkingHours(demand.getEstimateWorkingHours());
                }
                // 已处理提交是到需求处理人
                demandUserId = demand.getCreateBy();
                break;
            // 完成需求
            case DemandDetails.MAKE_TYPE_FINISH:
                // 完成需求时，状态为已完成，流程状态为已完成
                demandStatus = Demand.STATUS_FINISHED;
                demandFlowStatus = Demand.FLOW_STATUS_FINISH;
                // 完成需求时，用户为需求发起人
                demandUserId = demand.getCreateBy();
                // 完成时间为当前时间
                demandDetails.setEndDate(nowDate);
                break;
            // 关闭需求
            case DemandDetails.MAKE_TYPE_ClOSE:
                // 关闭需求时，状态为已关闭，流程状态为已关闭
                demandStatus = Demand.STATUS_ClOSE;
                demandFlowStatus = Demand.FLOW_STATUS_ClOSE;
                // 关闭需求，用户与上一个流程段一致
                demandUserId = demand.getNowUserId();
                break;
            default:
                demandStatus = "";
                demandFlowStatus = "";
        }
        // 排序+1
        demandDetails.setFlowSort(lastDemandDetails == null ? 0 : lastDemandDetails.getFlowSort() + 1);
        demandDetails.setDemandStatus(demandStatus);
        demandDetails.setDemandFlowStatus(demandFlowStatus);
        demandDetails.setDemandId(demandId);
        demandDetails.setUserId(demandUserId);
        int result = demandDetailsDao.insert(demandDetails);

        // 修改需求当前流程参数
        // 更新当前流程用户
        demand.setNowUserId(demandDetails.getUserId());
        if (estimateFinishDate != null) {
            demand.setEstimateFinishDate(estimateFinishDate);
        }
        if (estimateWorkingHours != null) {
            demand.setEstimateWorkingHours(estimateWorkingHours);
        }
        // 更新流程状态
        demand.setNowUserId(demandUserId);
        demand.setStatus(demandStatus);
        demand.setFlowStatus(demandFlowStatus);
        dao.updateById(demand);
        // 发送短信（已提交和已完成除外）
        if (!StringUtils.inString(demandDetails.getDemandFlowStatus(), Demand.FLOW_STATUS_SUBMITTED, Demand.FLOW_STATUS_FINISH)) {
            System.out.println("**************************正在发送短信1**********************************");
            // 发送给当前用户
            User user = userService.getById(demandDetails.getUserId());
            if (user != null) {
                System.out.println("**************************正在发送短信2**********************************");
                String mobile = user.getMobile();
                if (StringUtils.isNotBlank(mobile)) {
                    System.out.println("**************************正在发送短信3**********************************");
                    // 判断状态是否为已处理
                    if (Demand.STATUS_PROCESSED.equals(demand.getStatus())) {
                        // 已处理
                        CdpUtils.sendMobileMessage(mobile, "您提交的《" + demand.getName() + "》需求已处理完毕，请登录平台及时确认。");
                    } else {
                        // 获取发起人名称
                        User createByUser = userService.getById(demand.getCreateBy());
                        CdpUtils.sendMobileMessage(mobile, "您有一个新的需求《" + demand.getName() + "》—" + createByUser.getName() + "，请登录平台及时处理。");
                    }
                }
            }
        }
        return result;
    }

}
